<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>Strings in C#</title>
<link rel="stylesheet" href="/cfg/format.css" type="text/css">
<meta http-equiv="content-type" content="text/html; charset=utf-8">
<meta name="keywords" content="C#, learn C#, strings, .NET, Mono, programming">
<meta name="description" content="This part of the C# tutorial covers C# strings.">
<meta name="language" content="en">
<meta name="author" content="Jan Bodnar">
<meta name="distribution" content="global">

<script type="text/javascript" src="/lib/jquery.js"></script>
<script type="text/javascript" src="/lib/common.js"></script>

</head>

<body>

<div class="container">

<div id="wide_ad" class="ltow">
<script type="text/javascript"><!--
google_ad_client = "pub-9706709751191532";
/* 160x600, August 2011 */
google_ad_slot = "2484182563";
google_ad_width = 160;
google_ad_height = 600;
//-->
</script>
<script type="text/javascript"
src="http://pagead2.googlesyndication.com/pagead/show_ads.js">
</script>
</div>



<div class="content">


<a href="/" title="Home">Home</a>&nbsp;
<a href="..">Contents</a>


<h1>Strings in C#</h1>

<p>
In this part of the C# tutorial, we will work with string 
data in more detail.  
</p>

<p>
Strings are the most important data types in computer languages. 
That is why we dedicate a whole chapter to working with strings in C#. 
</p>

<script type="text/javascript"><!--
google_ad_client = "pub-9706709751191532";
/* NewSquare */
google_ad_slot = "0364418177";
google_ad_width = 300;
google_ad_height = 250;
//-->
</script> 
<script type="text/javascript"
src="http://pagead2.googlesyndication.com/pagead/show_ads.js"> 
</script>

<p>
A string is a sequence of characters. In C#, a string is a sequence of
unicode characters. It is a data type which stores a sequence of data values, 
usually bytes, in which elements usually stand for characters according 
to a character encoding. When a string appears literally in source code, 
it is known as a <b class="keyword">string literal</b>.
</p>


<h2>First example</h2>

<p>
In C# string literals are enclosed by double quotes. 
</p>


<pre class="code">
using System;

public class CSharpApp
{
    static void Main() 
    {
        string str1 = "There are 10";
        string str2 = " apples";
        
        Console.WriteLine(str1 + str2);
        
        Console.WriteLine("The length of the first string is " 
            + str1.Length.ToString() + " characters");
    }
}
</pre>

<p>
In the preceding example, we create two string variables.
Then we add them and compute the length of the first string.
</p>

<pre class="explanation">
string str1 = "There are 10";
</pre>

<p>
A string variable is declared and initiated. 
</p>

<pre class="explanation">
Console.WriteLine(str1 + str2);
</pre>

<p>
Two strings are concatenated. We use the + operator
to add two strings. 
</p>

<pre class="explanation">
Console.WriteLine("The length of the first string is " 
    + str1.Length.ToString() + " characters");
</pre>

<p>
The <code>Length</code> property is used to
determine the length of the string. 
</p>

<pre>
$ ./basics.exe 
There are 10 apples
The length of the first string is 12 characters
</pre>

<p>
Running the example gives this result. 
</p>


<h2>Using quotes</h2>

<p>
What if we wanted to display quotes, for example in a direct speech?
In such a case, inner quotes must be escaped.
</p>

<pre class="code">
using System;

public class CSharpApp
{
    static void Main() 
    {
        Console.WriteLine("There are many stars.");
        Console.WriteLine("He said, \"Which one is your favourite?\"");
    }
}
</pre>

<p>
We use the (\) character to escape additional quotes.
</p>

<pre>
$ ./quotes.exe 
There are many stars.
He said, "Which one is your favourite?"
</pre>

<p>
Output. 
</p>

<h2>Multiline strings</h2>

<p>
It is possible to create a multiline string in C#. 
</p>

<pre class="code">
using System;

public class CSharpApp
{
    static void Main() 
    {
        string multiString = @"I cheated myself
like I knew I would
I told ya, I was trouble
you know that I'm no good";
         
        Console.WriteLine(multiString);

    }
}
</pre>

<p>
A multiline string can be created easily by using
the (@) character at the beginning of the string. 
</p>

<pre>
$ ./multiline.exe 
I cheated myself
like I knew I would
I told ya, I was trouble
you know that I'm no good
</pre>


<h2>Comparing strings</h2>

<p>
We can compare two strings with a (==) operator.
</p>

<pre class="code">
using System;

public class CSharpApp
{
    static void Main() 
    {
        Console.WriteLine("12" == "12"); 
        Console.WriteLine("17" == "9");
        Console.WriteLine("aa" == "ab");
    }
}
</pre>

<p>
Comparing strings.
</p>


<pre>
$ ./compare.exe 
True
False
False
</pre>

<p>
Output of the program. 
</p>

<hr class="btm">

<p>
There is a <code>string.Compare()</code> method, which compares two specified strings
and returns an integer that indicates their relative position in the sort order.
If the returned value is less than zero, the first string is less than the second. If
it returns zero, both strings are equal. Finally, if the returned value is greater than
zero, the first string is greater than the second.
</p>

<pre class="code">
using System;

public class CSharpApp
{
    static void Main() 
    {
        string str1 = "ZetCode";
        string str2 = "zetcode";
         
        Console.WriteLine(string.Compare(str1, str2, true));
        Console.WriteLine(string.Compare(str1, str2, false));
    }
}
</pre>

<p>
There is an optional third ignoreCase argument, that determines, if the case
should be honored or not. 
</p>

<pre class="explanation">
Console.WriteLine(string.Compare(str1, str2, true));
</pre>

<p>
Compare two strings and ignore the case. This line prints 0
to the console. 
</p>


<h2>String methods</h2>


<p>
C# has useful built-in methods that 
can be used for working with strings. 
</p>


<p>
The <code>Join()</code> and <code>Split()</code>
are very handy methods. 
</p>

<pre class="code">
using System;

public class CSharpApp
{
    static void Main() 
    {
        string[] items = new string[] {"C#", "Visual Basic", 
            "Java", "Perl"};

        string langs = string.Join(",", items);
        Console.WriteLine(langs);

        string[] ls = langs.Split(',');

        foreach (string lang in ls) 
        {
            Console.WriteLine(lang);
        }
    }
}
</pre>

<p>
In our program, we will join and split strings.
</p>

<pre class="explanation">
string[] items = new string[] {"C#", "Visual Basic", 
    "Java", "Perl"};
</pre>

<p>
This is an array of strings. These strings are going to
be joined.
</p>

<pre class="explanation">
string langs = string.Join(",", items);
</pre>

<p>
All words from the array are joined. We build one string from them.
There will be a comma character between each two words. 
</p>

<pre class="explanation">
string[] ls = langs.Split(',');
</pre>

<p>
As a reverse operation, we split the langs string. The 
<code>Split()</code> method returns an array of
words, delimited by a character. In our case it is a 
comma character. 
</p>

<pre class="explanation">
foreach (string lang in ls) 
{
    Console.WriteLine(lang);
}
</pre>

<p>
We go through the array and print its elements. 
</p>

<pre>
$ ./joinsplit.exe 
C#,Visual Basic,Java,Perl
C#
Visual Basic
Java
Perl
</pre>

<p>
Output of the example. 
</p>

<hr class="btm">

<pre class="code">
using System;

public class CSharpApp
{
    static void Main() 
    {
        string str = "Determination";

        Console.WriteLine(str.Contains("e"));
        Console.WriteLine(str.IndexOf("e"));
        Console.WriteLine(str.LastIndexOf("i"));

        Console.WriteLine(str.ToUpper());
        Console.WriteLine(str.ToLower());
    }
}
</pre>

<p>
We introduce five string methods in the above example. 
</p>

<pre class="explanation">
Console.WriteLine(str.Contains("e"));
</pre>

<p>
The <code>Contains()</code> method returns True
if the string contains a specific character. 
</p>

<pre class="explanation">
Console.WriteLine(str.IndexOf("e"));
</pre>

<p>
The <code>IndexOf()</code> returns the first index
of a letter in the string. 
</p>

<pre class="explanation">
Console.WriteLine(str.LastIndexOf("i"));
</pre>

<p>
The <code>LastIndexOf()</code> methods
returns the last index of a letter in a string. 
</p>

<pre class="explanation">
Console.WriteLine(str.ToUpper());
Console.WriteLine(str.ToLower());
</pre>

<p>
Letters of the string are converted to uppercase with 
the <code>ToUpper()</code> method and to lowercase
with the <code>ToLower()</code> method.
</p>


<pre>
$ ./strmethods.exe 
True
1
10
DETERMINATION
determination
</pre>

<p>
Running the program. 
</p>

<h2>Copy vs Clone</h2>

<p>
We will describe a difference between two methods. <code>Copy()</code>
and <code>Clone()</code>. The <code>Copy()</code> method creates 
a new instance of string with the same value as a specified string.
The <code>Clone()</code> method returns a reference 
to the string, which is being cloned. It is not an independent 
copy of the string on the Heap. It is another reference on the same
string. 
</p>

<pre class="code">
using System;

public class CSharpApp
{
    static void Main() 
    {
        string str = "ZetCode";
        
        string cloned = (string) str.Clone();
        string copied = string.Copy(str);

        Console.WriteLine(str.Equals(cloned)); // prints true
        Console.WriteLine(str.Equals(copied)); // prints true

        Console.WriteLine(ReferenceEquals(str, cloned)); // prints true
        Console.WriteLine(ReferenceEquals(str, copied)); // prints false
    }
}
</pre>

<p>
Our example demonstrates the difference between the two methods. 
</p>

<pre class="explanation">
string cloned = (string) str.Clone();
string copied = string.Copy(str);
</pre>

<p>
The string value is cloned and copied. 
</p>

<pre class="explanation">
Console.WriteLine(str.Equals(cloned)); // prints true
Console.WriteLine(str.Equals(copied)); // prints true
</pre>

<p>
The <code>Equals()</code> method determines whether 
two string objects have the same value. The contents of 
all three strings are the same. 
</p>

<pre class="explanation">
Console.WriteLine(ReferenceEquals(str, cloned)); // prints true
Console.WriteLine(ReferenceEquals(str, copied)); // prints false
</pre>

<p>
The <code>ReferenceEquals()</code> method compares
the two reference objects. Therefore comparing a
copied string to the original string returns false. 
Because they are two distinct objects. 
</p>

<h2>Formatting strings</h2>

<p>
In the next examples, we will format strings. The .NET
Framework has a feature called <b>composite formatting</b>. 
It is supported by <b class="keyword">Format()</b> and
<b class="keyword">WriteLine()</b> methods. A method takes 
a list of objects and a composite format string as input. 
The format string consists of fixed string plus some format items.
These format items are indexed placeholders which correspond to the objects
in the list. 
</p>

<p>
The format item has the following syntax:
</p>

<pre>
{index[,length][:formatString]}
</pre>

<p>
The index component is mandatory. It is a number starting from 0 that refers
to an item from the list of objects. Multiple items can refer to the same element
of the list of objects. An object is ignored, if it is not referenced by a format
item. If we refer outside the bounds of the list of objects, a runtime exception
is thrown. 
</p>

<p>
The length component is optional. It is the minimum number of characters in
the string representation of the parameter. If positive, the parameter is 
right-aligned; if negative, it is left-aligned. If it is specified, 
there must by a colon separating the index and the length. 
</p>

<p>
The formatString is optional. It is a string that formats a value is a 
specific way. It can be used to format dates, times, numbers or enumerations. 
</p>

<p>
Here we show, how to work with length component of the
format items. We print three columns of numbers to the terminal. 
Left, middle and right aligned. 
</p>

<pre class="code">
using System;

public class CSharpApp
{
    static void Main() 
    {
        int oranges = 2; 
        int apples  = 4;
        int bananas = 3;
    
        string str1 = "There are {0} oranges, {1} apples and " + 
            "{2} bananas";

        string str2 = "There are {1} oranges, {2} bananas and " + 
            "{0} apples";
            
        Console.WriteLine(str1, oranges, apples, bananas);
        Console.WriteLine(str2, apples, oranges, bananas);
    }
}
</pre>

<p>
We print a simple message to the console. We use only index component
of the format item. 
</p>

<pre class="explanation">
string str1 = "There are {0} oranges, {1} apples and " + 
    "{2} bananas";
</pre>

<p>
The {0}, {1}, and {2} are format items. We specify the index component.
Other components are optional. 
</p>

<pre class="explanation">
Console.WriteLine(str1, oranges, apples, bananas);
</pre>

<p>
Now we put together the composite formatting. We have the string and
the list of objects (oranges, apples, bananas). The {0} format item
refers to the oranges. The <code>WriteLine()</code> method
replaces the {0} format item with the contents of the oranges
variable.  
</p>

<pre class="explanation">
string str2 = "There are {1} oranges, {2} bananas and " + 
    "{0} apples";
</pre>

<p>
The order of the format items referring to the objects is notation
important. 
</p>

<pre>
$ ./format1.exe 
There are 2 oranges, 4 apples and 3 bananas
There are 2 oranges, 3 bananas and 4 apples
</pre>

<hr class="btm">

<pre class="code">
using System;

public class CSharpApp
{
    static void Main() 
    {
        Console.WriteLine("{0}  {1, 12}", 
            "Decimal", "Hexadecimal");

        Console.WriteLine("{0:D}  {1,8:X}",  
            502, 546);
        Console.WriteLine("{0:D}  {1,8:X}", 
            345, 765);
        Console.WriteLine("{0:D}  {1,8:X}", 
            320, 654);
        Console.WriteLine("{0:D}  {1,8:X}", 
            120, 834);
        Console.WriteLine("{0:D}  {1,8:X}", 
            620, 454);
    }
}
</pre>

<p>
We print numbers in a decimal and hexadecimal
format. We also align the numbers using the length
component.
</p>

<pre class="explanation">
Console.WriteLine("{0:D}  {1,8:X}",  
    502, 546);
</pre>

<p>
The {0:D} format item specifies, the first item from the
list of supplied objects will be taken and formatted in 
the decimal format. The {1,8:X} format item takes the
second item. Formats it in the hexadecimal format (:X).
And the string length will be 8 characters (,8). Because the
number has only three characters, it is right aligned and
padded with empty strings.  
</p>

<pre>
$ ./format2.exe 
Decimal   Hexadecimal
502       222
345       2FD
320       28E
120       342
620       1C6
</pre>

<p>
Running the example. 
</p>

<hr class="btm">

<p>
The last two examples will format numeric and date data.
</p>

<pre class="code">
using System;

public class CSharpApp
{
    static void Main() 
    {
        Console.WriteLine(string.Format("Number: {0:N}", 126));
        Console.WriteLine(string.Format("Scientific: {0:E}", 126));
        Console.WriteLine(string.Format("Currency: {0:C}", 126));
        Console.WriteLine(string.Format("Percent: {0:P}", 126));
        Console.WriteLine(string.Format("Hexadecimal: {0:X}", 126));
    }
}
</pre>

<p>
The example demonstrates the standard
formatting specifiers for numbers. Number 126 is printed 
in five different formats; normal, scientific, currency,
percent and hexadecimal. 
</p>

<pre>
$ ./format3.exe 
Number: 126.00
Scientific: 1.260000E+002
Currency: $126.00
Percent: 12,600.00 %
Hexadecimal: 7E
</pre>


<p>
Output.
</p>

<hr class="btm">

<p>
Finally, we will format date and time data. 
</p>

<pre class="code">
using System;

public class CSharpApp
{
    public static void Main() 
    {
        DateTime today = DateTime.Now;

        Console.WriteLine(string.Format("Short date: {0:d}", today));
        Console.WriteLine(string.Format("Long date: {0:D}", today));
        Console.WriteLine(string.Format("Short time: {0:t}", today));
        Console.WriteLine(string.Format("Long time: {0:T}", today));
        Console.WriteLine(string.Format("Month: {0:M}", today));
        Console.WriteLine(string.Format("Year: {0:Y}", today));
    }
}
</pre>

<p>
The preceding example demonstrates the standard
formatting specifiers for dates. 
</p>

<pre>
$ ./format4.exe 
Short date: 4/11/2011
Long date: Monday, April 11, 2011
Short time: 11:14 AM
Long time: 11:14:54 AM
Month: April 11
Year: April, 2011
</pre>

<p>
Output.
</p>

<p>
This part of the C# tutorial covered strings. 
</p>



<div class="botNav, center">
<span class="botNavItem"><a href="/">Home</a></span> ‡ <span class="botNavItem"><a href="..">Contents</a></span> ‡ 
<span class="botNavItem"><a href="#">Top of Page</a></span>
</div>

<div class="footer">
<div class="signature">
<a href="/">ZetCode</a> last modified October 15, 2010  <span class="copyright">&copy; 2007 - 2013 Jan Bodnar</span>
</div>
</div>

</div> <!-- content -->

</div> <!-- container -->

</body>
</html>

